This is something I'd like to do somehow too. I think it needs to be kind of
fractalized, iterations from large to small perturbations. Unfortunately,
people were discussing function-made fractals elsewhere here at the
newsgroups and seemed this isn't possible because recursive calls into a
function aren't allowed. Or I hadn't noticed if anyone said there was a way.

Obviously you realize what needs to be done and just have not found a
suitable answer. Hope you do.

I worked a bit from your description and got a lumpy mountain that looks
like some sort of  Baked Alaska desert. It's goofy but thought it was
interesting, isosurfaces usually are.
See script below your quote if you'd like...
--
Farewell,
Bob

"Justin Smith" <t74### [at] yahoocom> wrote in message
news:web.3d9bb34c33fc79509a66a6680@news.povray.org...
>
> The problem is that when I make the noise large enough (either by scaling
> the #declared pigment function in the declaration, or by increasing the
> multiplier at the end of subtracting it from the base function, or both),
> it always leaves "floaters"... pieces of terrain that are not actually
> connected or are connected by very thin sections to the main object. If I
> make the noise small enough to prevent this from being noticeable, the
> general silhouette of the mountain is still a perfect paraboloid and looks
> very unnatural.

// needs AA or there are terrible lines
light_source {
 -10000*z, 1
 rotate <45,45,0>
}

camera {
 location -150*z
 look_at -10*y
 angle 40
 rotate <15,0,0>
}

#declare F_Paraboloid=
function {
 (x*x+y+z*z)
}

#declare F_Crackle=
function {
 pigment  {
  crackle
  turbulence 0.125
  scale 10
 }
}

#declare F_Agate=
function {
 pigment  {
  agate
  agate_turb 0.125
  scale 10
 }
}

#declare F_GradientY=
function {
 pigment  {
  gradient y
  scallop_wave
  turbulence 0.125
  scale 0.5
 }
}

#include "functions.inc"

isosurface {
 function {

  F_Paraboloid((x*x)/999,y/9*f_noise3d(x/9,y/33,z/9), (z*z)/999)
  -((F_Crackle(x,y,z).gray*2

+F_Agate(x,y,z).gray*2))*f_noise3d(x/3,y/9,z/3)*F_GradientY(x,y,z).gray*0.3
 }
 contained_by {
  box { -50,50 }
 }
 threshold 1
 accuracy 1 // yes, very low accuracy
 max_gradient 1 // again, not much here
 // evaluate 2,1,0.95
scale <1,0.25,1>
 pigment {
  rgb <1,1,1>
 }
}

Post a reply to this message